MoE Distribute Dispatch V2（Full-Mesh）SIMT 内核实现分析

1. 算子概述

1.1 这个算子是做什么的？

在混合专家（MoE, Mixture of Experts）大模型中，每一层有上百个"专家"（每个专家本质上是一个 FFN 子网络），分布在不同的 AI 加速卡上。每个 token（词元）只会激活其中的 Top-K 个专家。因此必须有一个通信算子，把本卡的 token "快递"到持有目标专家的那张卡上——这就是 Dispatch（分发）算子。训练/推理完成后，还有反向的 Combine（回收）算子 把专家的输出寄回来。

本文件的实现有三大特点，也是本文的主线：

2. SIMT 架构基础概念

2.1 什么是 SIMT？和 SIMD 有什么不同？

SIMD（单指令多数据）：一条向量指令同时处理一整块数据，编程时把数据切到 UB（Unified Buffer，统一缓存）里，用 Add、DataCopy 等 API 搬运和计算——适合规则的大块数据。

SIMT（单指令多线程）：像 GPU 一样，一个 AI Core 内启动成百上千个线程，每个线程有独立的程序计数器、可独立分支，通过原子操作和栅栏协作——适合不规则、依赖数据内容的场景。Dispatch 恰恰就是典型的不规则场景：每个 token 该写到哪个槽位，只有运行时才知道。

2.2 Ascend 上的 SIMT 编程模型（本文代码用到的全部语法）

本算子只用到了下面这一套"最小语法集"，先看懂它们，后面读代码就毫无障碍：

2.3 内存层级与线程协作的三个关键机制

机制一：stride 循环（线程步进遍历）

1024 个线程要处理 BS×K 个元素（可能远多于 1024），标准写法是"每个线程从自己的 tid 出发，每次跨线程总数前进一步"：

// simt_prepare_mapping 内，L139：
for (int row = tid; row < axisBS*axisK; row += PREPARE_THREADS_NUM) {
    // 线程 0 处理 row=0,1024,2048...；线程 1 处理 row=1,1025...
}

机制二：UB 原子计数器 = "取号机"

多个线程同时要往同一个专家的"槽位数组"里写数据，谁写第 0 槽、谁写第 1 槽？atomicAdd 返回旧值，天然就是一个并发取号机：

// L143-148：原子加 1 并拿到"我是第几个到达的"（pre_cnt）
int pre_cnt = atomicAdd(dstExpCnt + cur_ep_id, 1);
dstExpOffsetList[cur_ep_id*axisBS + pre_cnt] = row;  // 按取到的号入座，绝不冲突

机制三：栅栏 + 软同步

• 核内：ThreadBarrier() 保证所有线程完成第一阶段（计数/写入）后才开始第二阶段（排序/消费）。
• 核间：AIV 之间没有硬件全局栅栏，本算子用"在 GM 状态区写标志 + 轮询求和"实现软同步（见 §5.8 的 flag+cnt 协议、§4.5 的 stageDone）。

3. 算子设计思路

3.1 通信背景：Full-Mesh 与通信窗（Window）

"Full-Mesh" 指每张卡与所有 EP（Expert Parallel）域内的卡都建立了一条直连通道。发送方不需要"经过中转"，直接把数据写到对方卡的接收窗口里。每张卡有一块 shmemBuffer_（共享内存窗口），并被切分成若干功能区（L462 GetWindAddrByRankId 及其周边函数）：

3.2 多核角色分工：一条 AIV 流水线

算子运行时有 aivNum_ 个 AIV 核，代码没有让所有核干同一件事，而是把核按编号切段，各司其职（角色划分计算见 L773 SetTilingDataAndCal，调度见 L4278 Process）：

3.3 生产者-消费者流水线

整个算子是一条精心设计的异步流水线：Stage 核只管"打包发货清单 + 把 token 放进发货架"，URMA 核负责"填写运单（WQE）"，Doorbell 核负责"按顺序按门铃通知运货车"，CumSum 核负责"对账（各专家收了多少）"，最后所有核作为收件方把自己专家的数据按到达顺序上架（连续化）。它们之间几乎不互相等待，靠窗口里的标志位协议衔接。

4. 核心算法流程

4.1 总体流程图

4.2 阶段一：Token 本地缓存（Stage 核 → send buffer）

1. 专家 ID 预处理（ExpIdsCopyAndMaskCal）：把 expertIds（BS×K 的矩阵）搬进 UB，若存在 token 掩码 / 专家掩码 / 零计算专家，用 CompareScalar + GatherMask 生成筛选掩码，无效位置填 -1。这一步保证后续"每个有效 (token, topk) 对"恰好被发送一次。
2. 按 token 分核（SendToMoeExpertNew）：每个 Stage 核认领一段 token（SplitToCore 均分 + 余数前置），把每个 token 只写一次到本地 send buffer 第 tokenId 格。
3. 打包（TokenToExpertInQuant / TokenToExpert）：可选量化，然后 FillTriple 在数据尾部写入三元组 (epRankId, tokenIndex, topkIndex) 以及完整的 top-k expert id 列表（L1015-1028），再按 512B 块铺到 send buffer。
4. 完工广播（PublishStageDone）：置自己核的 stageDone 标志 = 1.0。

4.3 阶段二：URMA 远程发送（WQE 核）

1. 建映射：VF simt_prepare_mapping（1024 线程）扫全部 expertIds，用 UB 原子计数把"目标专家在本核负责区间内"的 (token, 顺序) 记进桶里，并统计要发给远端的 token 总数。
2. 等绿灯：轮询 headReady 标志（L3772），确认 Doorbell 核已读完 SQ 头指针，避免并发改写竞争。
3. 造运单：VF buildRemoteWqeDesc（128 线程 = 4 warp，每 warp 负责一个"专家×槽位段"）计算每条转发的 (本地地址, 远端地址, 目标卡, 长度, 操作码) 五元组，写入 UB 上的 WQE 描述数组。
4. 写入硬件队列：VF simt_nw_mj_vf 三阶段把运单变成硬件可消费的 64B WQE，写入各卡对应的 SQ（Send Queue）环形缓冲区。

4.4 阶段三：敲门铃（Doorbell 核）

WQE 写完只是"把信投进邮筒"，还要"摇晃通知旗"硬件才开始搬运——这就是 doorbell（门铃）。由 1 个专用核（RingDoorbell）轮询每个 jetty（每卡 1 条通道）的 headRecord 位图，发现连续就绪的 WQE 后批量 st_dev(currHead, dbAddr) 通知硬件。它还负责前置工作：从 ACLSHMEM 拷贝 SQ/CQ 上下文（get_sqs_and_cqs_xb）并清缓存直写。

4.5 阶段四：计数与 CumSum（对账）

CumSum 核组（≤16 核，CalCumSum）完成"收发对账"：

1. 报数：CalAndSendCnt 统计"本卡会发给每个专家多少 token"，以 flag+cnt 格式写入各目标卡状态区；
2. 对账：WaitDispatch 自旋等待所有源卡报数完成（flag 全为 1），随后 GatherSumRecvCnt + GetCumSum 做跨核前缀和（并行前缀：核 i 得到核 0..i-1 的累计收件数），结果写 sendCountsOut 与 workspace；
3. 输出专家 token 数：一个核执行 SetExpertTokenNums，对各专家跨所有源卡求和。

4.6 阶段五：接收整理（所有核 → LocalWindowCopy）

最后所有核汇合执行 LocalWindowCopy：每个核认领若干 (源卡×本地专家) 数据块，轮询块的到达标志（§5.9），到多少搬多少，把窗口里的"按源卡分块"数据重排成"按专家连续排列"的 expandXOut，同时写 expandIdxOut，最后清理标志供下一轮复用。这是典型的"工作窃取/轮询调度"：数据没到就跳去看下一个块，先到先搬，最大化吞吐。

5. 关键代码逻辑解析

5.1 常量与全局布局（先记住这几个数字）

5.2 simt_prepare_mapping：原子计数 + 桶内排序

L122-246。输入是 expertIds，输出是"我负责的每个专家收到的 token 索引列表（按 token 序号升序）"。两阶段：

// 阶段 1：扫描全部 BS×K 个槽位（stride 循环）
for (int row = tid; row < axisBS*axisK; row += PREPARE_THREADS_NUM) {
    int ep_id = *(expertIds + row);
    if (ep_id >= beginExpertId && ep_id < expertNum + beginExpertId) {
        int cur_ep_id = ep_id - beginExpertId;          // 换算成本核区间内编号
        int pre_cnt = atomicAdd(dstExpCnt + cur_ep_id, 1); // 取号：我是该专家第 pre_cnt 个 token
        dstExpOffsetList[cur_ep_id*axisBS + pre_cnt] = row; // 入桶（桶宽 axisBS）
    }
}
Simt::ThreadBarrier();   // 全员到齐才开始阶段 2（排序要读完整桶）

// 阶段 2：对每个桶元素，数一数桶里比它小的元素个数 = 它的升序位置（计数排序思想）
for (uint32_t t = tid; t < expertNum * axisBS; t += PREPARE_THREADS_NUM) {
    ...
    for (uint32_t c = 0; c < offsetNum; ++c)
        if (dstExpOffsetList[curExpertSlotBase + c] < curTokenOriginalOffset)
            sortedSlotInExpert++;
    dstExpOrderedOffsetList[curExpertSlotBase + sortedSlotInExpert] = curTokenOriginalOffset;
}

5.3 buildRemoteWqeDesc：warp 协作生成运单

L250-299。128 线程 = 4 warp，每轮（loopIdx）每个 warp 认领一个"专家×32 槽"块：

const uint32_t tid = Simt::GetThreadIdx<0>();
const uint32_t warpId = tid / WARP_SIZE, laneId = tid % WARP_SIZE;
// 本 warp 本轮负责的 (专家, 第几批32槽)
uint32_t currBlock = (BUILD_THREADS_NUM / WARP_SIZE) * loopIdx + warpId;
uint32_t mySlot    = currBatchOfCurrExp * WARP_SIZE + laneId;  // 本线程检查的槽位
if (targetRankId != localRankId && mySlot < validOffsetCnt) {  // 只处理远端 & 有效槽
    uint32_t taskOffset = atomicAdd(finishedWqeDescNum, 1); // 取号：运单序号
    localAddrList[taskOffset]  = srcBaseAddr + tokenId * tokenCommSize;       // 源：send buffer 第 tokenId 格
    remoteWqeAddrList[taskOffset] = remoteBaseAddr + (targetExpertOnRank * axisBS + mySlot) * tokenCommSize; // 目的：远端窗口槽位
    dstRankList[taskOffset] = targetRankId;  messageLenList[taskOffset] = tokenCommSize;
}

5.4 Token 发送：512B 块布局与三元组

TokenToExpertInQuant 展示了"一个 token 如何被铺成若干 512B 块"：blockCntPerToken_ = Ceil(hOutSizeAlign_, 480)，每块 480B 数据 + 32B（其中 flag float 占位）。UB 内用 Copy 指令以 256B 为段、跨步 16/15 双段拷贝，把数据填入 outTensor_ 的两个半区（flagPadOffset_ 在 0/256 间乒乓），再整块 DataCopy 到 GM。

5.5 simt_nw_mj_vf：WQE 三阶段写入（性能精髓）

L3277-3407。SQ（发送队列）是每条 jetty 一个环形缓冲，多线程并发写环形队列必须解决"队列头指针 headAddr 在 GM 上、每次 atomicAdd 很贵"的问题。解法是三阶段聚合：

// Phase 2（L3334-3341）：核心技巧
for (int sqIdx = tid; sqIdx < total_jetty; sqIdx += WQE_THREADS_NUM) {
    uint32_t count = sqWqeCount[sqIdx];
    if (count > 0U)
        sqBaseHead[sqIdx] = atomicAdd((__gm__ uint32_t *)(sqs[sqIdx].headAddr), count);
        // 一次预留 count 个连续槽位，Phase 3 在区间内自由分配
}
// Phase 3（L3344-3361）：写入 + 栅栏 + 置位图
...
simt_write_wqe_v4(my_sq, my_head, ...);
asc_threadfence();                     // 确保 WQE 先于位图可见
atomicOr(&HeadRecordUB[...], 1U << bitInWord);  // 标记第 my_head % maxHeadRecordSlot 槽就绪

最后（L3365-3378）按 warp 把 UB 位图中非零 word atomicOr 合并到 GM 的 HeadRecord——Doorbell 核读的就是它。

5.6 simt_write_wqe_v4：64B WQE 位域布局

L3031-3092。WQE（Work Queue Element）是 URMA 硬件的"运单"，固定 64B，两个 ulonglong4（各 32B）写入。关键位域：

5.7 RingDoorbell：位图扫描与敲门

L4001-4275。为什么单独一个核干这事？因为 SIMT 线程无法正确地直接敲门铃（源码注释 L3381 明确说明），于是 WQE 核把就绪信息写进位图，由 Doorbell 核（Scalar 核属性）串行确认后敲：

1. 初始化：读各 SQ 当前 head 作 prevHead（防竞争基线）；set_gm_value VF 清零 headRecord 区；向各 WQE 核的 headReady 槽写魔数 20260817（L4096），放行 WQE 生成。
2. 主循环（L4165）：对每张有欠账的远端卡，按 32 位 word 批量拉取位图，用 ScalarGetSFFValue<0> 统计从 prevHead 起连续置位的个数 readyCount（半 word 特判右移，L4200-4209），然后 st_dev(prevHead + wqeCount, dbAddr) 一次敲响 wqeCount 个 WQE 的门铃。
3. 终止条件：ranksLeftToSend == 0（calc_rank_token_cnt 预先算好每卡需发总数）。

5.8 计数与跨核前缀和：flag+cnt 协议与软同步

这是全文件最精巧的核间同步设计。状态区每个 32B 格：第 0 个 int32 按 float 解释是 flag（发完置 0x3F800000=1.0f），第 1 个 int32 是 cnt（L1460-1463 用带掩码的 Duplicate 一次铺出这种"每 8 个元素第 1 个是 1.0"的模板）。

值得注意的细节：每次轮询前都要 DataCacheCleanAndInvalid<..., CACHELINE_OUT>（L1689）——AIV 的 DCache 不与远端写自动同步，不刷缓存会死循环读旧值。

5.9 到达检测与输出整理

CheckDataArriveWithFlag —— 一块一块地"验货"

L1922-2049。对某源块中 copyCnt 个 token（每 token 含 blockCntPerToken_ 个 512B 子块）：

// 1) 把每个子块尾部的 flag(float) 拉到 UB：DataCopy 跨步参数 {1, 512-32B ...} 天然"跳格"采集
DataCopy(flagRecvTensor_, dataFlagGlobal[token * tokenStride], flagCopyParams);
// 2) GatherMask 抽出所有 flag → CompareScalar(flag==1.0) 得位图
GatherMask(flagGatherOutTensor_, flagRecvTensor_, flagRecvGatherMask_, ...);
CompareScalar(flagCompResultU8_, flagGatherOutTensor_, float(1), CMPMODE::EQ, compareCount);
// 3) ScalarGetSFFValue<0> 找位图中第一个 0（= 第一个未到的子块）
//    前面连续为 1 的子块数 / blockCntPerToken_ = 已完整到达的 token 数
return arriveFlagNum / blockCntPerToken_;

WaitAndFormatOutput / CopyInAndOut —— 轮询式收件 + top-k 修正

WaitAndFormatOutput 以"(index+1)%validNum 轮询"在多个源块间跳转：哪块到得多先搬哪块；一次最多搬 maxCopyTokenCnt 个 token（受 UB 容量约束，L2107）。CopyInAndOut 整块 DataCopy 到 UB 后：

// L2076-2093：URMA 转发时三元组里的 topkIdx 被统一填成 0，
// 但 token 携带了完整 top-k expert id 列表 —— 在这里现场"验明正身"
for (uint32_t j = 0; j < axisK_; j++) {
    int32_t curExpertId = xOutInt32Tensor(topKInfoOffset + j);
    if (dstExpertId == curExpertId) {
        xOutInt32Tensor(tokenQuantAlign_ + 2) = j;   // 修正为真实 topk slot
        break;
    }
}
DataCopyPad(expandIdxGMTensor_[dstPosition * EXPAND_IDX_INFO], xOutInt32Tensor[...], ...);

搬完后若整块收完，还要把窗口里的 flag 清零（L2162-2170），配合 dataState_ 双缓冲，为下一轮 dispatch 复位现场。

5.10 Process：总调度

if ASCEND_IS_AIV {
    if (aivId_ < aivUsedStage_) {          // ── 发件组
        AllToAllDispatch();                 // 打包 token → send buffer / 共享专家直发
        PublishStageDone();                 // 完工标志
        tpipe_->Reset();
        if (aivId_ < aivUsedRemoteWqe_)  URMASendToken();  // 远端：建映射+造 WQE
        else                             SelfCopyToken();  // 本卡：等 stage 全完成直接拷
    } else if (aivId_ < aivCumSumStart_) {
        RingDoorbell();                     // ── 敲门组（1 核）
    } else {
        CalCumSum();                        // ── 对账组（≤16 核）
    }
    PipeBarrier<PIPE_ALL>();
    LocalWindowCopy();                      // ── 所有核：收件整理（本卡作为收件方）
}

6. 内存布局速查（收发双方约定）

7. 性能优化策略盘点

7.1 效果评估与代价分析

8. 潜在改进方向

1. 桶内排序 O(n²) → O(n log n) 或 O(n)：simt_prepare_mapping 阶段 2 的比较计数排序在单专家 token 数很大时代价高。可用 warp 级 bitonic 排序，或直接利用"取号即到达序"的性质改为按 (row) 排序的基数思路（源码中已保留 warp 协作版注释 L217-245，说明作者已探索过）。
2. 轮询自旋的能效：WaitDispatch、headReady 等自旋循环在高频场景会烧核（含 DCache 清理开销）。可引入带退避的轮询间隔，或硬件事件（如有）替代。
3. 魔法数字与重复代码收敛：WQE 写入函数 5 个版本并存、大量被注释掉的调试块（如 L1951-2006）、DEBUG_ON/DEBUG_CLOCK_ON 调试宏混布，建议抽公共模板并用 constexpr 常量表管理位域。
4. PORT_NUM/JETTY_NUM 目前为 1：L106-107，多 jetty 可提升单卡聚合带宽与 WQE 并行度，三阶段路由代码已为其预留（(writerId + ordinal) % jetty_per_rank），值得展开验证。
5. URMAPollCQ 超时机制未完成：L3474 处 300 万 cycle 超时仅打印即 break，可能掩盖故障；建议计入失败统计并上抛。
6. 可移植性：#if __NPU_ARCH__ == 3510 分支较多，位域打包依赖 make_ulonglong4；若要跨代移植，需把 WQE 布局抽象成版本化 trait。
7. _recv 前缀和核数上限 16（CUMSUM_MAX_CORE_NUM）在大规模专家数下每核状态段变长，轮询拉取量增大，可考虑树形归约替代"全量广播 + 局部 GatherMask"。

9. 算子接口规范（输入 / 输出）

9.1 核函数入口与 Init 参数

算子以模板类 MoeDistributeDispatchV2FullMesh（L349）组织，Host 侧完成 Tiling 后调用 Init 绑定全部资源，再调用 Process 执行（每个 AIV 核各跑一次，aivId_ = GetBlockIdx()）。Init 签名（L958-962）即算子的完整接口契约：

__aicore__ inline void Init(
    GM_ADDR mc2Context,                       // MC2 共享上下文（含各卡 epHcclBuffer / shmem 基址）
    GM_ADDR x,                                // 输入 token 隐藏状态
    GM_ADDR expertIds,                        // Top-K 专家 ID 矩阵
    GM_ADDR scales,                           // 平滑 scale（可选）
    GM_ADDR xActiveMask,                      // token/专家 掩码（可选）
    GM_ADDR elasticInfo,                      // 弹性缩容信息（可选）
    GM_ADDR performanceInfo,                  // 性能打点输出（isPerformance 时）
    GM_ADDR expandXOut,                       // 输出：按专家连续排列的 token 数据
    GM_ADDR dynamicScalesOut,                 // 输出：动态量化 scale
    GM_ADDR expandIdxOut,                     // 输出：路由三元组
    GM_ADDR expertTokenNumsOut,               // 输出：每专家 token 数
    GM_ADDR sendCountsOut,                    // 输出：累计收件数前缀和
    GM_ADDR tpSendCountsOut,                  // 输出：tp 域计数（兼作耗时打点区）
    GM_ADDR workspaceGM, TPipe *pipe,          // 中间 workspace 与 UB 管道
    const MoeDistributeDispatchV2TilingData *tilingData);  // Host 预计算参数包

9.2 输入张量详表

9.3 输出张量详表

9.4 Tiling 参数（Host 传入）

以下字段全部来自 SetTilingData（L744-770）与 Init 中的补充读取（L969-987），是 Host 侧 Tiling 阶段必须正确填写的参数面：

9.5 量化模式与数据类型组合

10. 算子生命周期总览

10.1 五个生命周期阶段

10.2 Init 初始化详解

Init（L958-1012） 按严格顺序完成 7 件事：

1. 饱和模式设置：3510 架构关闭浮点饱和（L964-966），避免量化 Cast 溢出钳位；
2. 上下文选择：isMc2Context 时使用 Mc2MoeContext，否则取 HCCL 上下文并 CheckWindowSize 校验通信窗容量（L970-978）；
3. 张量绑定：为 10 个 GlobalTensor 调用 SetGlobalBuffer（L979-986）；
4. 参数解析：SetTilingDataAndCal（§10.3）；
5. 标志清理：ClearStageDoneFlags（L834）把本卡窗口 StageDone 区清零，保证本轮"完工广播"从干净状态开始；
6. 数据状态初始化：SetDataStatus（L924）读取/翻转 dataState_ 双缓冲，并据此计算 shmemDataSizeOffset_ / winDataSizeOffset_（L952-955），把窗口切到本轮使用的半区；
7. 窗口地址族初始化：计算 windowGM_ / statusDataSpaceGM_ / recvCntWorkspaceGM_ 及 DataCopy 参数（L995-1008）。

10.3 参数解析与派生量计算

SetTilingDataAndCal（L773-831）是"参数 → 布局"的推导中枢，关键派生链：

11. 核心算法逻辑架构与数学原理

11.1 问题形式化

设本卡 token 为 x_i ∈ R^H（i ∈ [0,BS)），路由矩阵 E ∈ Z^{BS×K}，E[i][j] = e 表示 token i 的第 j 个激活专家编号。定义映射：

σ : (i, j) ──▶ ( 目标卡 r(e), 本地专家 e_local = e % moeExpertNumPerRank, 组内槽位 s )

算子的目标是：对每个本地专家 e_local，把"全 EP 域所有发往它的 token"按确定的顺序（源卡优先、卡内按 token 序）连续拼成 expandX 的行段，且同时给出逆映射 expandIdx。形式化地，输出行位置由两级前缀和唯一确定：

dstPosition(源块 src) = sendCountsOut[src - 1]  +  该块内已收完成数

11.2 发送槽位寻址公式

发送侧的核心是"把每个 (i,j) 对号入座到远端窗口的某个 512B 槽位"。三种路径的寻址公式：

11.3 接收定位与跨核前缀和

接收侧两个定位量：

• 源块号反解（L2132）：expertMapTensor_ 存储复合索引 src = e_local × epWorldSize + srcRank，反解 srcDataBlockIdx = (src % epWorldSize) × localExpertNum + src / epWorldSize，即窗口中"该源卡发给该本地专家"的数据块首地址偏移；
• 目标行定位（L2151-2152）：dstPosition = sendCntTensor_[src-1] + expertFinishNumTensor_[index]——前者是 CumSum 核组算出的"排在 src 之前的所有块的总收件数"（全局前缀），后者是本核在 src 块内已收的行数（局部计数）。

跨核前缀和由 CumSum 核组协作完成（GetCumSum L1612-1668）：核 k 收到全部核的 cnt 广播后，对 [0, k) 求和即得自己的全局偏移——本质是把 O(N²) 的两两交换压缩为"一轮全广播 + 一轮局部 GatherMask/Sum"。

11.4 到达判定原理

定义块级指示函数 flag(t, b) ∈ {0, 1}（token t 的第 b 个 512B 子块尾部的 float）。则：

token t 已完整到达  ⟺  ∀ b < blockCntPerToken : flag(t, b) = 1
可收 token 数  =  |{ 最大前缀 t : flag(0..t, ·) 全 1 }|  =  (连续置位 flag 总数) / blockCntPerToken

该判定的正确性依赖三个不变量：(1) 发送端"先数据后 flag"的写序（硬件 DMA 顺序 + 栅栏）；(2) 接收端读前 DataCacheCleanAndInvalid 的可见性；(3) 到达的前缀有序性（由发送端升序填槽 + WQE 按序写 + 门铃按序敲共同保证）。三者任一被破坏，接收端要么死等要么收到半块脏数据——这也是 §7.1 总评中提到的协议脆弱点。

12. 处理阶段划分与执行顺序（时序图）

下图为一次 dispatch 中本卡各角色与远端卡、URMA 硬件之间的消息时序。三条泳道并行推进（发送链 / 计数链 / 通信链），仅在标注的握手点同步：

阶段执行顺序约束表

13. 关键步骤与代码对应关系

14. 上下游模块接口与数据交互

接口交互协议清单

15. 术语表

AIV / AI Core

昇腾 AI 处理器上的向量计算核；本算子 SetBlockDim 启动的每个"核"即一个 AIV，GetBlockIdx() 得到 aivId。

SIMT / SIMD

单指令多线程 / 单指令多数据；前者线程级并行（本算子），后者向量级并行。

VF（Vector Function）

__simt_vf__ 标记的核内线程函数，通过 Simt::VF_CALL 以 N 线程启动。

LAUNCH_BOUND(N)

声明 VF 线程数的编译期常量宏，必须与 Dim3{N} 一致。

Warp / lane

32 个 SIMT 线程的执行单元；lane 为 warp 内线程号（tid%32）。

UB（Unified Buffer）

核内高速缓存，同核线程以 __ubuf__ 指针共享；容量约 190-216KB 可用。

GM（Global Memory）

全局显存（HBM），__gm__ 指针访问，跨核跨卡可见。

EP（Expert Parallel）

专家并行：把 MoE 的专家切分到多卡。

Top-K / axisK

每个 token 激活的专家数；expertIds 形状为 BS×K。

Window（通信窗）

每卡注册的一块可被其他卡远程读写的共享内存区（§3-1 图）。

URMA

AI 侧远程内存访问引擎：AI Core 写 WQE + 敲门铃即可触发跨卡 DMA，不经 Host。

WQE（Work Queue Element）

URMA 的 64B 工作描述符，含远端地址/本地地址/长度/操作码等。

SQ / CQ / jetty

发送队列 / 完成队列 / 通信通道实例；本算子每卡 1 port × 1 jetty。

Doorbell（门铃）

向硬件寄存器写"队列头推进值"以触发处理，st_dev 实现。

flag+cnt 协议

32B 状态格中 float 标志位（1.0=就绪）+ int32 计数，本算子的核心同步原语。

软同步

无硬件全局栅栏时，用"写标志 → 轮询求和 → 清零"在核间达成同步的方式。

dataState / 双缓冲

窗口数据分两半交替使用，轮次 r 用 dataState=r&1，避免读写交叉。

expandX / expandIdx

输出：按专家连续排列的 token 数据 / 每输出行的 (rank, tokenIdx, topkIdx) 三元组。

CumSum（前缀和）

sendCountsOut 是"各源卡累计收件数"的单调序列，用于把源块映射到 expandX 的连续区间。

ScalarGetSFFValue

位扫描 intrinsic：找最低位 1（<1>）或最低位 0（<0>），返回 -1 表示无。

DataCacheCleanAndInvalid

清并失效 DCache 行，强制后续读穿透到 GM——读远端更新前的必备动作。

st_dev

向设备侧（非普通内存）地址写值的指令，用于敲硬件门铃。

headReadyFlag = 20260817

WQE 核与 Doorbell 核的握手魔数（日期戳）。

16. 附录：调试手段与延伸阅读

16.1 内置维测设施

16.2 与本项目的关系

本头文件位于参考实现目录 ref/，本项目 ascend_deepep 的对应内核在 kernels/dispatch_udma.cpp，接口层在 csrc/ops/dispatch.cpp。对照阅读时可重点关注：send buffer 槽位映射、WQE 三阶段写入、flag+cnt 同步协议是否在自研版本中保留/演进。

16.3 推荐阅读顺序（针对初学者）

本文档基于源码静态分析生成（2026-08-31）；行号引用以本次提供的 deepep_moe_dis_dispatch.h 为准。